package com.lagou.homework2.no1;

import java.util.Random;

/**
 * 定义一个长度为[16][16]的整型二维数组并输入或指定所有位置的元素值，分别实现二维数组中所有行和所有列中所有元素的累加和并打印。
 * 再分别实现二维数组中左上角到右下角和右上角到左下角所有元素的累加和并打印。
 */
public class ArraysEntity {
    //定义一个整型的二维数组
    private int[][] arr;
    //定义数组维度参数
    private int x;
    private int y;
    //定义一个参数代表所有行元素的累加和
    private int[] sumRows;
    //定义一个参数代表所有列元素的累加和
    private int[] sumCells;
    //定义一个参数代表数组中左上角到右下角的累加和
    private int sumLeft_Right;
    //定义一个参数代表数组中右上角到左下角元素的累加和
    private int sumRight_Left;
    //声明一个无参构造器
    public ArraysEntity() {
    }
    //声明一个有参构造器
    public ArraysEntity(int x,int y) {
        setX(x);//初始化值0
        setY(y);//初始化值0
        setSumRows(new int[x]);//初始化数组维度为二维数组的行参数
        setSumCells(new int[y]);//初始化数组维度为二维数组的列参数
        setSumLeft_Right(0);//初始化值0
        setSumRight_Left(0);//初始化值0
        this.arr = new int[x][y];
    }
    //随机给二维数组赋值
    public int[][] setValues(){
        Random random = new Random();//定义一个随机数发生器
        //循环数组行
        for(int m=0;m<arr.length;m++){
            for (int n=0;n<arr[m].length;n++){
                this.arr[m][n] = random.nextInt(10);//生成一个随机数并赋值给数组
            }
        }
        return arr;
    }
    //打印每行元素的累加和
    public int[] sumRows(){
        int rowsValue ;//定义一个变量记录每行的和
        //行和规则：arr[0][0]+arr[0][1]+arr[0][2].....+arr[0][16]
        for(int m=0;m<x;m++){
            rowsValue = 0;//每行循环开始将rowsValue初始化为0
            for (int n=0;n<y;n++){
                rowsValue +=arr[m][n];//累加和
            }
            sumRows[m] = rowsValue;//将每一行累加的和记录在一维数组中
        }
        return sumRows;
    }
    //打印每列元素的累加和
    public int[] sumCells(){
        int cellsValue;//定义一个变量记录每列的和
        int cnt;//定义一个累加次数
        //列和规则：arr[0][0]+arr[1][0]+arr[2][0].....+arr[16][0]
        for(int m=0;m<x;m++){
            cellsValue = 0;//每列循环开始将rowsValue初始化为0
            cnt = 0;
            while (cnt<y){//取列值，如果cnt小于列值就取值相加
                cellsValue +=arr[cnt][m];
                cnt++;
            }
            sumCells[m] = cellsValue;//将每一列累加的和记录在一维数组中
        }
        return sumCells;
    }
    //实现左上角到右下角的累加和
    public int sumLeft_Right(){
        //累加规则：arr[0][0]+arr[1][1]+arr[2][2].....+arr[16][16]
        for(int m=0;m<y;m++){
            for(int n=0;n<x;n++){
                if(m==n){//如果行索引和列索引相同时则取值相加
                    sumLeft_Right +=arr[m][n];//累加和
                }
            }
        }
        return sumLeft_Right;
    }
    //实现右上角到左下角的累加和
    public int sumRight_Left(){
    //累加规则：arr[0][16]+arr[1][15]+arr[2][14].....+arr[0][0]
        for(int m=0;m<x;m++){
            for(int n=y-1;n>=0;n--){
                if(m+n==x-1){//如果行索引和列索引的和相加等于行数或者列数（行数和列数相等）
                    sumRight_Left +=arr[m][n];//累加和
                }
            }
        }
        return sumRight_Left;
    }
    //生成get，set方法
    public int[][] getArr() {
        return arr;
    }

    public void setArr(int[][] arr) {
        this.arr = arr;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public int[] getSumRows() {
        return sumRows;
    }

    public void setSumRows(int[] sumRows) {
        this.sumRows = sumRows;
    }

    public int[] getSumCells() {
        return sumCells;
    }

    public void setSumCells(int[] sumCells) {
        this.sumCells = sumCells;
    }

    public int getSumLeft_Right() {
        return sumLeft_Right;
    }

    public void setSumLeft_Right(int sumLeft_Right) {
        this.sumLeft_Right = sumLeft_Right;
    }

    public int getSumRight_Left() {
        return sumRight_Left;
    }

    public void setSumRight_Left(int sumRight_Left) {
        this.sumRight_Left = sumRight_Left;
    }
}
